package com.ffggffgfv.backend.controller;

import com.ffggffgfv.backend.dto.PermissionDTO;
import com.ffggffgfv.backend.entity.Permission;
import com.ffggffgfv.backend.service.PermissionService;
import com.ffggffgfv.backend.util.JWTUtil;
import com.ffggffgfv.backend.util.Result;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * 权限控制器
 */
@RestController
@RequestMapping("/api/permissions")
public class PermissionController {

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private JWTUtil jwtUtil;

    /**
     * 获取权限列表（树形结构）
     *
     * @param type     权限类型（可选）
     * @param parentId 父级ID（可选）
     * @param token    JWT令牌
     * @return 权限列表
     */
    @GetMapping
    public Result getPermissions(
            @RequestParam(required = false) Integer type,
            @RequestParam(required = false) Long parentId,
            @RequestHeader("Authorization") String token) {

        // 权限验证
        if (!validateAdminPermission(token)) {
            return Result.forbidden("无权访问");
        }

        List<Permission> permissions = permissionService.findAll(type, parentId);
        return Result.success(permissions);
    }

    /**
     * 创建权限
     *
     * @param permissionDTO 权限DTO
     * @param token         JWT令牌
     * @return 创建结果
     */
    @PostMapping
    public Result createPermission(
            @RequestBody PermissionDTO permissionDTO,
            @RequestHeader("Authorization") String token) {

        // 权限验证（仅超级管理员）
        if (!validateSuperAdminPermission(token)) {
            return Result.forbidden("无权创建权限");
        }

        // 参数校验
        if (permissionDTO.getName() == null || permissionDTO.getName().trim().isEmpty()) {
            return Result.validateFailed("权限名称不能为空");
        }
        if (permissionDTO.getCode() == null || permissionDTO.getCode().trim().isEmpty()) {
            return Result.validateFailed("权限编码不能为空");
        }
        if (permissionDTO.getType() == null) {
            return Result.validateFailed("权限类型不能为空");
        }

        // 检查编码是否已存在
        if (permissionService.isCodeExists(permissionDTO.getCode())) {
            return Result.conflict("权限编码已存在");
        }

        // 创建权限
        Permission permission = new Permission();
        BeanUtils.copyProperties(permissionDTO, permission);

        Permission createdPermission = permissionService.createPermission(permission);

        return Result.success(createdPermission, "权限创建成功");
    }

    /**
     * 验证是否具有管理员权限
     *
     * @param token JWT令牌
     * @return 是否有管理员权限
     */
    private boolean validateAdminPermission(String token) {
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                return jwtUtil.hasAdminRole(token);
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }

    /**
     * 验证是否具有超级管理员权限
     *
     * @param token JWT令牌
     * @return 是否有超级管理员权限
     */
    private boolean validateSuperAdminPermission(String token) {
        if (token != null && token.startsWith("Bearer ")) {
            token = token.substring(7);
            try {
                // 在实际项目中，应该根据角色编码判断是否为超级管理员
                // 这里简化处理，假设有ROLE_SUPER_ADMIN角色
                List<String> roles = jwtUtil.extractClaim(token, claims -> {
                    return claims.get("roles", List.class);
                });
                return roles != null && roles.contains("ROLE_SUPER_ADMIN");
            } catch (Exception e) {
                return false;
            }
        }
        return false;
    }
}
